home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / solaris2 / jdk / include / interpre.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-30  |  11.9 KB  |  382 lines
  1. /*
  2.  * @(#)interpreter.h    1.57 95/10/18  
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. /*
  21.  * Definitions for the interperter    6/27/91
  22.  */
  23.  
  24. #ifndef _INTERPRETER_H_
  25. #define _INTERPRETER_H_
  26.  
  27. #include <standardlib.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <bool.h>
  32. #include <config.h>
  33.  
  34. extern char *progname;
  35. extern unsigned char *codebuf;
  36. extern int verbose;
  37. extern int verbosegc;
  38. extern int noasyncgc;
  39. extern int debugagent;
  40. extern ClassClass *classclass;    /* class java/lang/Class */
  41. extern ClassClass *classobject;    /* class java/lang/Object */
  42.  
  43. enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
  44.  
  45. extern int verifyclasses;
  46.  
  47. #define FINALIZER_METHOD_NAME "finalize"
  48. #define FINALIZER_METHOD_SIGNATURE "()V"
  49.  
  50. #ifdef TRACING
  51.   extern int trace;
  52.   extern int tracem;
  53.   extern char *opnames[256];
  54.   extern void trace_method(struct execenv*, struct methodblock*, int, int);
  55.   enum { TRACE_METHOD_ENTER, TRACE_METHOD_RETURN, TRACE_METHOD_NATIVE_RETURN };
  56. # define TRACE_METHOD(ee, mb, args_size, type) \
  57.       if (tracem) trace_method(ee, mb, args_size, type); else
  58.  
  59. #else
  60. # define trace  0
  61. # define tracem 0
  62. # define TRACE_METHOD(ee, mb, args_size, type) 
  63. #endif
  64.  
  65.  
  66. /* Get a constant pool index, from a pc */
  67. #define GET_INDEX(ptr) (((int)((ptr)[0]) << 8) | (ptr)[1])
  68.  
  69. extern char *Object2CString(Handle *);
  70.  
  71. #define METHOD_FLAG_BITS 5
  72. #define FLAG_MASK       ((1<<METHOD_FLAG_BITS)-1)  /* valid flag bits */
  73. #define METHOD_MASK     (~FLAG_MASK)  /* valid mtable ptr bits */
  74. #define LENGTH_MASK     METHOD_MASK
  75.  
  76. #define obj_flags(o) \
  77.     (((unsigned long) (o)->methods) & FLAG_MASK)
  78. #define obj_length(o)   \
  79.     (((unsigned long) (o)->methods) >> METHOD_FLAG_BITS)
  80.  
  81. #define mkatype(t,l) ((struct methodtable *) (((l) << METHOD_FLAG_BITS)|(t)))
  82. #define atype(m) ((m) & FLAG_MASK)
  83.  
  84.  
  85. #define obj_methodtable(obj) ((obj)->methods)
  86. #define obj_classblock(obj) ((obj)->methods->classdescriptor)
  87.  
  88. #define obj_array_methodtable(obj) \
  89.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? obj_methodtable((obj))      \
  90.                                            : cbMethodTable(classobject))
  91. #define obj_array_classblock(obj) \
  92.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? (obj)->methods->classdescriptor \
  93.                                            : classobject)
  94.  
  95. #define mt_slot(methodtable, slot) (methodtable)->methods[slot]
  96.  
  97. #define uobj_getslot(o, slot) (o)[slot]
  98. #define uobj_setslot(o, slot, v) (uobj_getslot(o, slot) = (v))
  99.  
  100. #define obj_getslot(o, slot) uobj_getslot(unhand(o), slot)
  101. #define obj_setslot(o, slot, v) (obj_getslot(o, slot) = (v))
  102.  
  103. #define obj_monitor(handlep) ((int) handlep)
  104.  
  105.  
  106. struct arrayinfo {
  107.     int index;
  108.     char sig;      /* type signature. */
  109.     char *name;
  110.     int factor;
  111. };
  112.  
  113.  
  114. typedef union stack_item {
  115.     /* Non pointer items */
  116.     int            i;
  117.     float          f;
  118.     OBJECT         o;
  119.     /* Pointer items */
  120.     Handle        *h;
  121.     void          *p;
  122.     unsigned char *addr;
  123. } stack_item;
  124.  
  125. struct execenv {
  126.     struct javastack  *initial_stack;
  127.     struct javaframe  *current_frame; 
  128.     Handle           *thread;        /* vague type to avoid include files */
  129.     char              exceptionKind;
  130.     union {
  131.     Handle          *exc;        /* holds exception object */
  132.     unsigned char *addr;        /* holds pc for stack overflow */
  133.     } exception;
  134. };
  135.  
  136. typedef struct execenv ExecEnv;
  137.  
  138. #define PRIVILEGED_EE ((ExecEnv*)-1)
  139.  
  140. #define JAVASTACK_CHUNK_SIZE 2000
  141. struct javastack {
  142.     struct execenv  *execenv;        /* execenv we belong to */
  143.     struct javastack *prev;          /* previous stack of this execenv */
  144.     struct javastack *next;          /* next stack of this execenv */
  145.     stack_item      *end_data;      /* address of end of data */
  146.     unsigned int     stack_so_far;  /* total space used by this chunk and
  147.                      * all previous chunks. */
  148.     stack_item       data[JAVASTACK_CHUNK_SIZE];    /* actual data */
  149.  
  150. };
  151.  
  152. typedef struct javastack JavaStack;
  153.  
  154.  
  155. struct javaframe {
  156.     /* N. B.the first two items in structure shouldn't be needed by function
  157.      * return, since they may be overwritten by dreturn/lreturn
  158.      */
  159.     stack_item         *optop;          /* current top of stack */
  160.     stack_item         *vars;           /* pointer to this frame's vars */
  161.     struct javaframe    *prev;   /* previous java frame. */
  162.     struct javastack    *javastack;                      
  163.     unsigned char      *lastpc;           /* pc of last instruction */
  164.     unsigned char      *returnpc;      /* pc of next instruction */
  165.     struct methodblock *current_method;/* method currently executing */
  166.     cp_item_type       *constant_pool; /* constant_pool of this method */
  167.     Handle             *monitor;       /* object locked by this method */
  168.     int                    mon_starttime; /* time this method began */
  169.     stack_item ostack[1];           /* start of this frame's stack */
  170. };
  171.  
  172. typedef struct javaframe JavaFrame; 
  173.  
  174.  
  175. /*
  176.  * Javaframe.exceptionKind is used to signal why the interpreter
  177.  * loop was exited.
  178.  */
  179. #define EXCKIND_NONE            0               /* return */
  180. #define EXCKIND_THROW        1        /* throw */
  181. #define EXCKIND_STKOVRFLW       2               /* stack overflow */
  182.  
  183.  
  184. #define exceptionClear(ee)    \
  185.     ((ee)->exceptionKind = EXCKIND_NONE);
  186.  
  187. #define exceptionOccurred(ee)    \
  188.     ((ee)->exceptionKind != EXCKIND_NONE)
  189.  
  190. #define exceptionThrow(ee, obj)    \
  191.     (ee)->exceptionKind = EXCKIND_THROW;            \
  192.     (ee)->exception.exc = (obj);
  193.  
  194.  
  195. extern long nbinclasses, sizebinclasses;
  196. extern ClassClass **binclasses;
  197.  
  198. /* stuff for dealing with handles */
  199. #define unhand(o) ((o)->obj)
  200.  
  201.  
  202. /* globals.c */
  203.  
  204. ClassClass** get_binclasses(void);
  205. ClassClass* get_classclass(void);
  206. ClassClass* get_classobject(void);
  207. long get_nbinclasses(void);
  208.  
  209. /* gc.c */
  210.  
  211. void InitializeAlloc(long max, long min);
  212. HObject *AllocHandle(struct methodtable *, ClassObject *);
  213. extern struct arrayinfo arrayinfo[];
  214. extern int64_t TotalObjectMemory(void);
  215. extern int64_t FreeObjectMemory(void);
  216. extern int64_t TotalHandleMemory(void);
  217. extern int64_t FreeHandleMemory(void);
  218. extern int tracegc;
  219.  
  220.  
  221. /* interpreter.c */
  222.  
  223. /* SignalError() -- Instantiate an object of the specified class. 
  224.  * Indicate that that error occurred.
  225.  */
  226. void SignalError(struct execenv *, char *, char *);
  227.  
  228. JavaStack *CreateNewJavaStack(ExecEnv *ee, JavaStack *previous_stack);
  229.  
  230. void InitializeExecEnv(ExecEnv *ee, Handle *thread);
  231. void DeleteExecEnv(ExecEnv *ee, Handle *thread);
  232. extern ExecEnv *DefaultExecEnv;
  233.  
  234.  
  235. HObject *execute_java_constructor(ExecEnv *,
  236.                  char *classname,
  237.                  ClassClass *cb,
  238.                  char *signature, ...);
  239. long execute_java_static_method(ExecEnv *, ClassClass *cb,
  240.                    char *method_name, char *signature, ...);
  241. long execute_java_dynamic_method(ExecEnv *, HObject *obj,
  242.                 char *method_name, char *signature, ...);
  243.      
  244. long do_execute_java_method(ExecEnv *ee, void *obj, 
  245.                char *method_name, char *signature, 
  246.                struct methodblock *mb,
  247.                bool_t isStaticCall, ...);
  248.  
  249. long do_execute_java_method_vararg(ExecEnv *ee, void *obj, 
  250.                    char *method_name, char *signature, 
  251.                    struct methodblock *mb,
  252.                    bool_t isStaticCall, va_list args, 
  253.                    long *highBits, bool_t shortFloats);
  254.  
  255. long now(void);
  256. void InitializeInterpreter(void);
  257. bool_t is_instance_of(Handle * h, ClassClass *dcb, ExecEnv *ee);
  258. bool_t ImplementsInterface(ClassClass *cb, ClassClass *icb, ExecEnv *ee);
  259. HObject *MultiArrayAlloc(int dimensions, ClassClass *, stack_item *sizes);
  260.  
  261.  
  262. struct stat;
  263.  
  264. bool_t dynoLink(struct methodblock *);
  265. char *str2rd(char *);
  266. char *unicode2rd(unicode *, long);
  267.  
  268. /* classruntime.c */
  269. HArrayOfChar *MakeString(char *, long);
  270. extern int ImportAcceptable;
  271.  
  272. ClassClass *FindClass(struct execenv *, char *, bool_t resolve);
  273. ClassClass *FindClassFromClass(struct execenv *, char *, bool_t resolve, ClassClass *from);
  274. char *ResolvePrototype(struct execenv *, ClassClass *cb);
  275. void RunStaticInitializers(ClassClass *cb);
  276. void InitializeInvoker(ClassClass *cb);
  277.  
  278. void LoadClassConstants(ClassClass *cb);
  279. bool_t ResolveClassStringConstant(ClassClass *, unsigned, struct execenv *);
  280. bool_t ResolveClassConstant(cp_item_type *, unsigned index, struct execenv *ee,
  281.                 unsigned mask);
  282. bool_t ResolveClassConstantFromClass(ClassClass *, unsigned index, 
  283.                      struct execenv *ee, unsigned mask);
  284.  
  285. bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
  286. bool_t VerifyFieldAccess(ClassClass *, ClassClass *, int, bool_t);
  287. bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2); 
  288.  
  289. char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
  290. unsigned NameAndTypeToHash(char *name, char *type);
  291. HObject *newobject(ClassClass *cb, unsigned char *pc, struct execenv *ee);
  292.  
  293.  
  294. char *pc2string(unsigned char *pc, struct methodblock *mb, char *buf, char *limit);
  295.  
  296. extern int InhibitExecute;
  297. Handle *ArrayAlloc(int, int);
  298. Handle *ObjAlloc(ClassClass *, long);
  299. int sizearray(int, int);
  300. extern char *remote_classname(Handle *);
  301. extern Handle *remote_clone(struct execenv *);
  302. extern long remote_cast(Handle *, ClassClass *);
  303. int pc2lineno(struct methodblock *, unsigned int);
  304.  
  305. /* From verify_code.c */
  306. bool_t verify_class_codes(ClassClass *cb);
  307.  
  308.  
  309. /* from profiler.c */
  310. extern int java_monitor;
  311. void javamon(int i);
  312. void java_mon(struct methodblock *caller, struct methodblock *callee, int time);
  313. void java_mon_dump(void);
  314.  
  315. /* from classloader.c */
  316. void AddBinClass(ClassClass * cb);
  317. void DelBinClass(ClassClass * cb);
  318. int LoadFile(char *fn, char *dir, char *SourceHint);
  319. int DoImport(char *name, char *SourceHint);
  320. ClassClass* createFakeArrayClass(char *name);
  321.  
  322.  
  323. unsigned Signature2ArgsSize(char *method_signature);
  324.  
  325. /* from classresolver.c */
  326. char *InitializeClass(ClassClass * cb, char **detail);
  327. char *ResolveClass(ClassClass * cb, char **detail);
  328. ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
  329. ClassClass *FindClassFromClass(struct execenv *ee, char *name, 
  330.                    bool_t resolve, ClassClass *from);
  331. void makeslottable(ClassClass * clb);
  332.  
  333.  
  334. /* from path_md.c */
  335. char **CLASSPATH(void);
  336.  
  337. /* from threadruntime.c */
  338. struct Hjava_lang_Thread *InitializeClassThread(ExecEnv *ee, char **errmsg);
  339. void InitializeMainThread(void);
  340. long *getclassvariable(struct ClassClass *cb, char *fname);
  341. struct Hjava_lang_Thread;
  342. char *thread_name(struct Hjava_lang_Thread *tid); 
  343.  
  344. void setThreadName(struct Hjava_lang_Thread *ht, HArrayOfChar *newName);
  345. HArrayOfChar *getThreadName(void);
  346.  
  347. /* from exception.c */
  348. struct Hjava_lang_Throwable;
  349. void fillInStackTrace(struct Hjava_lang_Throwable *handle, ExecEnv *ee);
  350.  
  351. /* from CompSupport.c */
  352. long CallInterpreted(register struct methodblock * mb, void *obj,...);
  353.  
  354. /* used to indicate of an object or remote or local */
  355. extern struct methodtable *remote_methodtable;
  356.  
  357. void unicode2str(unicode *, char *, long);
  358. unicode *str2unicode(char *, unicode *, long);
  359. void mangleMethodName(struct methodblock *mb, char *buffer, int buflen,
  360.               char *suffix);
  361.  
  362. /* string hash support */
  363. struct StrIDhash;
  364. unsigned short Str2ID(struct StrIDhash **, char *, void ***, int);
  365. char *ID2Str(struct StrIDhash *, unsigned short, void ***);
  366. void Str2IDFree(struct StrIDhash **);
  367. ExecEnv *EE(void);
  368.  
  369. /* Miscellaneous functions in util.c */
  370. char *unicode2rd(unicode *s, long len);
  371. void out_of_memory(void);
  372. void prints(char *s);
  373. void printus(unicode *str, long len);
  374. int jio_snprintf(char *str, size_t count, const char *fmt, ...);
  375. int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
  376.  
  377.  
  378.  
  379.  
  380. #endif /* ! _INTERPRETER_H_ */
  381.  
  382.